DEFINITION MODULE  Chars;

(*****************************************************************************)
(* In diesem Modul sammelt sich alles, was mit Einzelzeichen zu tun hat, d.h.*)
(* Definitionen von Konstanten - Control-Codes, Umlaute - ,Tests auf Zugehoe-*)
(* rigkeit eines Zeichens zu einer bestimmten Klasse und die Umwandlung von  *)
(* Zeichen einer Klasse in Zeichen einer anderen Klasse.                     *)
(*                                                                           *)
(* Thema Umlaute:                                                            *)
(* --------------------------------------------------------------------------*)
(* Falls mit dem Atari-Zeichensatz im Rechner und dem IBM-Zeichensatz auf dem*)
(* Drucker gearbeitet werden soll, bietet sich an, statt des 'SZ' das grie-  *)
(* chische Beta zu benutzen ( bei Atari und IBM gleich, andere Umlaute sind  *)
(* bei beiden gleich ). Dazu muessen nur die Konstanten "Beta" und "SZ ausge-*)
(* tauscht, und das Modul neu uebersetzt werden - es sind keine Aenderungen  *)
(* an den Prozeduren noetig. ( Hinweise fuer Assemblerversionen im IMPLEMEN- *)
(* TATION MODULE beachten ):                                                 *)
(*                                                                           *)
(* Das Paragraph-Zeichen hat keine Entsprechung im erweiterten IBM-Zeichen-  *)
(* satz. Um es daher auf Papier zu kriegen, muss der nationale ( deutsche )  *)
(* ASCII-Zeichensatz des Druckers eingeschaltet werden. Falls das Paragraph- *)
(* Zeichen oefter benutzt wird, bietet es sich an, saemtliche deutsche Son-  *)
(* derzeichen durch die Codes des deutschen ASCII-Zeichensatzes zu repraesen-*)
(* tieren. Hierfuer sind die Prozeduren mit dem 'ASCII' im Namen gedacht -   *)
(* sie verwenden fuer die deutschen Sonderzeichen die Codes des deutschen    *)
(* ASCII-Sonderzeichensatzes. Auf dem Bildschirm werden die so codierten     *)
(* Zeichen dann allerdings als Klammern, senkrechte Striche und Klammeraffe  *)
(* ausgegeben.                                                               *)
(*                                                                           *)
(* Da der Rechner natuerlich nicht feststellen kann, wie ein bestimmter Code *)
(* gerade interpretiert wird, d.h. ob der Atari-Code fuer die Sonderzeichen  *)
(* benutzt wird oder der ASCII-Code, muss der Benutzer sich im klaren sein,  *)
(* welchen Zeichencode er verwendet; andernfalls kann es manche Ueberra-     *)
(* schung geben.                                                             *)
(*                                                                           *)
(* Je nach Anwendungsfall kommt man mit einer Sorte von Funktionen aus, oder *)
(* man benutzt die eine fuer die Bildschirmdarstellung, die andere fuer den  *)
(* Ausdruck. In die jeweils andere Darstellung kann man mit den entsprechen- *)
(* den Konvertierroutinen gelangen.                                          *)
(*                                                                           *)
(* Man sollte sich bei allem was den Zeichensatz des Rechners betrifft der   *)
(* Routinen in diesem Modul bedienen, um rechnerunabhaengig zu bleiben.      *)
(*___________________________________________________________________________*)
(*    12-Feb-90 , Holger Kleinschmidt                                        *)
(*****************************************************************************)



TYPE
       CharClassTest = PROCEDURE ((* EIN/ -- *) CHAR ): BOOLEAN;

       CharConvert   = PROCEDURE ((* EIN/ -- *) CHAR ): CHAR;

       (* Durch diese Prozedurtypen koennen beliebige der folgenden
        * Funktionen, an andere Prozeduren als Parameter uebergeben
        * werden. Dies dient z.B. dazu, Strings auf jeweils unter-
        * schiedliche Weise mit derselben String-Prozedur zu bearbeiten.
        * Es koennen natuerlich auch eigene Prozeduren mit dieser
        * Funktionalitaet verwendet werden.
        *)

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)


PROCEDURE  IsASCII           ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsSpace           ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsControl         ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsSmallLetter     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsBigLetter       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsSmallUmlaut     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsSmallASCIIUmlaut((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsBigUmlaut       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsBigASCIIUmlaut  ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsBinDigit        ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsOctDigit        ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsDigit           ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsHexDigit        ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsPrintable       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsGraphic         ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsLetter          ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsAlphanumeric    ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsDelimiter       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsPunctuation     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsUmlaut          ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsASCIIUmlaut     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsSmallGerman     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsSmallASCIIGerman((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsBigGerman       ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsBigASCIIGerman  ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsGerman          ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;
PROCEDURE  IsASCIIGerman     ((* EIN/ -- *)  zeichen : CHAR ): BOOLEAN;

(*--------------------------------------------------------------------------
 | Die Funktionen pruefen , ob <zeichen> zu der Klasse von Zeichen gehoert, |
 | die durch die jeweiligen Funktionsnamen bezeichnet werden, dabei gelten  |
 | folgende Gleichungen:                                                    |
 |                                                                          |
 |  IsASCII(z)            = 0 <= z <= 7FH                                   |
 |  IsSpace(z)            = z IN { HT, VT, LF, FF, CR, ' ' }                |
 |  IsControl(z)          = ( z = DEL )  OR  ( z < ' ' )                    |
 |  IsSmallLetter(z)      = z IN {'a'..'z'}                                 |
 |  IsBigLetter(z)        = z IN {'A'..'Z'}                                 |
 |  IsSmallUmlaut(z)      = z IN { kleinesAE, kleinesOE, kleinesUE }        |
 |  IsSmallASCIIUmlaut(z) = z IN { kleinesASCIIae, kleinesASCIIoe,          |
 |                                 kleinesASCIIue                  }        |
 |  IsBigUmlaut(z)        = z IN { grossesAE, grossesOE, grossesUE }        |
 |  IsBigASCIIUmlaut(z)   = z IN { grossesASCIIae, grossesASCIIoe,          |
 |                                 grossesASCIIue                  }        |
 |  IsBinDigit(z)         = z IN {'0'..'1'}                                 |
 |  IsOctDigit            = IsBinDigit(z)     OR  z IN {'2'..'7'}           |
 |  IsDigit(z)            = IsOctDigit(z)     OR  z IN {'8', '9'}           |
 |  IsHexDigit(z)         = IsDigit(z)        OR  z IN {'a'..'f', 'A'..'F'} |
 |  IsPrintable(z)        = ~IsControl(z)                                   |
 |  IsGraphic(z)          = ~IsControl(z)      & ( z # ' ' )                |
 |  IsLetter(z)           = IsSmallLetter(z)  OR  IsBigLetter(z)            |
 |  IsAlphanumeric(z)     = IsLetter(z)       OR  IsDigit(z)                |
 |  IsDelimiter(z)        = IsASCII(z)         &  ~IsAlphanumeric(z)        |
 |  IsPunctuation(z)      = IsASCII(z)         &  IsGraphic(z)              |
 |                                             &  ~IsAlphanumeric(z)        |
 |  IsUmlaut(z)           = IsBigUmlaut(z)    OR  IsSmallUmlaut(z)          |
 |  IsASCIIUmlaut(z)      = IsBigASCIIUmlaut(z) OR IsSmallASCIIUmlaut(z)    |
 |  IsSmallGerman(z)      = IsSmallLetter(z)  OR  IsSmallUmlaut(z)          |
 |  IsSmallASCIIGerman(z) = IsSmallLetter(z)  OR  IsSmallASCIIUmlaut(z)     |
 |  IsBigGerman(z)        = IsBigLetter(z)    OR  IsBigUmlaut(z)            |
 |  IsBigASCIIGerman(z)   = IsBigLetter(z)    OR  IsBigASCIIUmlaut(z)       |
 |  IsGerman(z)           = IsLetter(z)       OR  IsUmlaut(z)               |
 |  IsASCIIGerman(z)      = IsLetter(z)       OR  IsASCIIUmlaut(z)          |
  --------------------------------------------------------------------------*)


PROCEDURE  IsOneOfSet ((* EIN/ -- *)  zeichen : CHAR;
                       (* EIN/ -- *)  charSet : ARRAY OF CHAR ): BOOLEAN;

(*--------------------------------------------------------------------------
 | Die Funktion prueft, ob <zeichen> eines der Zeichen ist, die in dem      |
 | String <charSet> vorkommen.                                              |
  --------------------------------------------------------------------------*)



PROCEDURE  ToAtariGerman ((* EIN/ -- *) zeichen : CHAR ): CHAR;

PROCEDURE  ToASCIIGerman ((* EIN/ -- *) zeichen : CHAR ): CHAR;

(*--------------------------------------------------------------------------
 | Die Prozeduren dienen dazu, fuer die deutschen Sonderzeichen die Codes   |
 | des einen Zeichensatzes in die des anderen umzurechnen. Ist <zeichen>    |
 | kein deutsches Sonderzeichen ( nach der Interpretation des jeweils ANDE- |
 | REN Zeichensatzes ! ), wird es unveraendert zurueckgeliefert.            |
 | Deutsche Sonderzeichen sind die Umlaute, das sz und der Paragraph.       |
  --------------------------------------------------------------------------*)



PROCEDURE  LowerCase            ((* EIN/ -- *) zeichen : CHAR ): CHAR;

PROCEDURE  LowerCaseGerman      ((* EIN/ -- *) zeichen : CHAR ): CHAR;

PROCEDURE  LowerCaseASCIIGerman ((* EIN/ -- *) zeichen : CHAR ): CHAR;

(*--------------------------------------------------------------------------
 | Wenn <zeichen> ein Grossbuchstabe bzw. grosser Umlaut ist, wird der ent- |
 | sprechende Kleinbuchstabe bzw. kleine Umlaut  zurueckgeliefert, sonst    |
 | <zeichen> unveraendert.                                                  |
 | 'LowerCaseGerman' ist fuer die Benutzung des Atari/IBM-Zeichensatzes bei |
 | den Umlauten gedacht, 'LowerCaseASCIIGerman' fuer die Benutzung des      |
 | deutschen ASCII-Sondercodes.                                             |
  --------------------------------------------------------------------------*)


PROCEDURE  CAPGerman      ((* EIN/ -- *) zeichen : CHAR ): CHAR;

PROCEDURE  CAPGermanASCII ((* EIN/ -- *) zeichen : CHAR ): CHAR;

(*--------------------------------------------------------------------------
 | Falls <zeichen> ein Kleinbuchstabe oder ein kleiner Umlaut ist, wird der |
 | entsprechende Grossbuchstabe bzw. der grosse Umlaut geliefert, sonst das |
 | unveraenderte <zeichen>.                                                 |
 | 'CAPGerman' muss verwendet werden, falls der Atari/IBM-Code fuer die Um- |
 | laute benutzt wird, 'CAPGermanASCII' falls der deutsche ASCII-Sondercode |
 | benutzt wird.                                                            |
  --------------------------------------------------------------------------*)


PROCEDURE  DigitToCard ((* EIN/ -- *) digit : CHAR ): CARDINAL;

PROCEDURE  CardToDigit ((* EIN/ -- *) card : CARDINAL ): CHAR;

(*--------------------------------------------------------------------------
 | Umwandlung einer Ziffer in den entsprechenden positiven Zahlenwert, bzw. |
 | umgekehrt.                                                               |
 |  - Es wird nicht ueberprueft, ob bei 'CardToDigit' <card> eine Zahl      |
 |    zwischen Null und neun ist, oder bei 'DigitToCard' <digit> eine       |
 |    Ziffer zwischen '0' und '9'. Also darauf achten:                      |
 |           '0' <= digit <= '9'     und     0 <= card <= 9                 |
  --------------------------------------------------------------------------*)

PROCEDURE  HexDigitToCard ((* EIN/ -- *) hexdigit : CHAR ): CARDINAL;

PROCEDURE  CardToHexDigit ((* EIN/ -- *) hexvalue : CARDINAL ): CHAR;

(*--------------------------------------------------------------------------
 | wie oben,                                                                |
 |  "CardToHexDigit" : ( 0..15 )                    -> ('0'..'9','A'..'F')  |
 |  "HexDigitToCard" : ('0'..'9','A'..'F','a'..'f') -> ( 0..15 )            |
  --------------------------------------------------------------------------*)


END  Chars.
